# -*- coding: utf-8 -*-

#    Copyright (C) 2014 by Promotux
#                       di Francesco Meloni snc - http://www.promotux.it/

#    Author: Francesco Meloni  <francesco@promotux.it>

#    This file is part of OdCollect.

#    OdCollect is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 2 of the License, or
#    (at your option) any later version.

#    OdCollect is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.

#    You should have received a copy of the GNU General Public License
#    along with OdCollect.  If not, see <http://www.gnu.org/licenses/>.


import json
from collections import OrderedDict
from sqlalchemy import *
from sqlalchemy.orm import *
from lib.alembic.migration import MigrationContext
from lib.alembic.operations import Operations
from lib.alembic import op

from Environment import *
from dao.Dao import Dao
from dao.DaoUtils import get_columns
from dao.Ente import Ente
from dao.Categoria import Categoria
from dao.Operatore import Operatore
from dao.Campo import Campo
from dao.CategoriaCampo import CategoriaCampo

from web_lib.webutils import leggiInSessione

try:
    t_open_data_store = Table('open_data_store', meta, schema=leggiInSessione(sezione="Main", chiave="schema"),autoload=True)
except:
    from data.opendatastore import t_open_data_store

fk_prefix =  leggiInSessione(sezione="Main", chiave="schema")+"."

colonne_opendatastore = colonne = get_columns(t_open_data_store)
if "hash_record" not in colonne_opendatastore:
    try:
        conn = engine.connect()
        ctx = MigrationContext.configure(conn)
        op = Operations(ctx)
        op.add_column('open_data_store', Column('hash_record', String(100), unique=True, nullable=True),schema=leggiInSessione(sezione="Main", chiave="schema"))
    except:
        delete_pickle()

if "hash_importazione" not in colonne_opendatastore:
    try:
        conn = engine.connect()
        ctx = MigrationContext.configure(conn)
        op = Operations(ctx)
        op.add_column('open_data_store', Column('hash_importazione', String(100), unique=False, nullable=True),schema=leggiInSessione(sezione="Main", chiave="schema"))
    except:
        delete_pickle()

if "id_operatore" not in colonne_opendatastore:
    #try:
    conn = engine.connect()
    ctx = MigrationContext.configure(conn)
    op = Operations(ctx)
    op.add_column('open_data_store', Column('id_operatore', Integer, ForeignKey(fk_prefix+'operatore.id'),nullable=True),schema=leggiInSessione(sezione="Main", chiave="schema"))
    #except:
        #delete_pickle()

if "id_utente" not in colonne_opendatastore:
    #try:
    conn = engine.connect()
    ctx = MigrationContext.configure(conn)
    op = Operations(ctx)
    op.add_column('open_data_store', Column('id_utente', Integer, ForeignKey(fk_prefix_main+'utente.id'),nullable=True),schema=leggiInSessione(sezione="Main", chiave="schema"))
    #except:
        #delete_pickle()

if "ordine" not in colonne_opendatastore:
    conn = engine.connect()
    ctx = MigrationContext.configure(conn)
    op = Operations(ctx)
    op.add_column('open_data_store', Column('ordine', Integer),schema=leggiInSessione(sezione="Main", chiave="schema"))


class OpenData(Dao):

    def __init__(self, req=None):
        Dao.__init__(self, entity=self)

    def filter_values(self,k,v):
        if k == 'id_categoria':
            dic = {k: t_open_data_store.c.id_categoria ==v}
        elif k =='id_ente':
            dic= {k: t_open_data_store.c.id_ente ==v}
        elif k =='daData':
            dic= {k: t_open_data_store.c.data_inserimento >= v}
        elif k =='aData':
            dic= {k: t_open_data_store.c.data_inserimento <= v}
        elif k =='hash_importazione':
            dic= {k: t_open_data_store.c.hash_importazione == v}
        elif k =='hash_record':
            dic= {k: t_open_data_store.c.hash_record == v}
        return  dic[k]

    @property
    def categoria(self):
        if self.id_categoria:
            a = Categoria().getRecord(id=self.id_categoria)
            if a:
                return a.denominazione
            else:
                return None
        else:
            return None

    @property
    def catalogo(self):
        if self.id_categoria:
            a = Categoria().getRecord(id=self.id_categoria)
            if a:
                return a.catalogo
            else:
                return None
        else:
            return None

    @property
    def ente(self):
        if self.id_ente:
            a = Ente().getRecord(id=self.id_ente)
            if a:
                return a.denominazione
            else:
                return None

    @property
    def operatore(self):
        if self.id_operatore:
            a = Operatore().getRecord(id=self.id_operatore)
            if a:
                return a.cognome.capitalize() +" "+ a.nome.capitalize()
            else:
                return None

    @property
    def info_supplementari(self):
        tai = CategoriaCampo().select(id_categoria=self.id_categoria,orderBy="ordine", batchSize=None)
        #idcampi = [dd.id_campo for dd in tai]
        #campi = Campo().select(idCampo=idcampi, batchSize=None)
        f= {}
        g=[]
        h= []
        #for c in Campo().select(batchSize=None):
            #campdict[c.denominazione] =  c.tipo_campo
        for t in tai:
            campo = Campo().getRecord(id=t.id_campo)
            f[campo.denominazione] = t.ordine
            g.append(campo.denominazione)
            if campo.visibile == True:
                h.append(campo.denominazione)
        return  {"ordine_campi":g},{"campi_visibili":h}

    #@property
    def dati_json(self):
        return json.loads(self.objson)[0]

    #@property
    def titoli(self):
        #from ftfy import fix_text
        try:
            dd = OrderedDict()
            for a in self.info_supplementari[0]["ordine_campi"][0:2]:
                if a in self.info_supplementari[1]["campi_visibili"]:
                    if a in json.loads(self.objson)[0]:
                        dd[a] = json.loads(self.objson)[0][a]
                        setattr(self, a, json.loads(self.objson)[0][a])
            return dd
        except:
            return None

    @property
    def titolo(self):
        c = ""
        #print "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC", [k  for k in self.titoli().values()]
        try:
            for k,v in self.titoli().iteritems():
                print "CCCCCCCCCCCC", c,v
                c = c + v
            return c
        except:
            return c

std_mapper = mapper(OpenData, t_open_data_store, properties={
            #'entee':relation(Ente, backref='opeendatastore'),
            #'categoriaa':relation(Categoria, backref='opendatastore'),
            #'objson':deferred(t_open_data_store.c.objson)
                }, order_by=t_open_data_store.c.data_inserimento.desc())
